#pragma once

#include <iostream>
#include <pthread.h>
#include <string>
#include <functional>
#include <unistd.h>

namespace Thread
{
    template<class T>
    using func_t = std::function<void(T&)>;
    
    template<class T>
    class myThread
    { 
    public:
        myThread(func_t<T> func, T& data, const std::string& name = "none-name")
            : _func(func)
            , _data(data)
            , _threadname(name)
            , _stop(true)
        {}

        static void* threadroutline(void* args) //类内函数带this指针，用static修饰后，类型才是 void* (void*)
        {//第一个参数args传入this指针，否则找不到成员_func，就无法调用用户指定的函数了
            myThread<T>* self = static_cast<myThread<T>*>(args);
            self->_func(self->_data);
            return nullptr;
        }

        bool start()
        {
            int n = pthread_create(&_tid, nullptr, threadroutline, this);//创建的时候，最后一个参数传this
            if(!n)
            {
                _stop = false;
                return true;
            }
            
            return false;
        }

        void Deatch()
        {
            if (!_stop)
                pthread_detach(_tid);
        }

        void join()
        {
            if (!_stop)
                pthread_join(_tid, nullptr);
        }

        void stop()
        {
            _stop = true;
        }

  private:
        T& _data;
        pthread_t _tid;
        std::string _threadname;
        func_t<T> _func;//线程执行的函数
        bool _stop;//标识当前线程是运行的还是暂停的
    };
}